Page({
  data: {
    inputValue: '', // 输入框内容
    isLoading: false, // 加载状态
    hasStartedConversation: false, // 是否开始对话（用于控制初始提示）
    isRecording: false,
    recordingTime: "00:00",
    recordingSeconds: 0,
    recordingTimer: null,
    animationTimer: null,
    animationState: 0,
    recordedFilePath: '', // 录音文件路径
    recordedDuration: 0,  // 录音时长(秒)
    messages: [], // 消息列表
    playingIndex: -1, // 当前播放的语音索引
    innerAudioContext: null, // 音频上下文实例
    recorderManager: null, // 录音管理器实例
    showResetBtn: false,
    recordingError: '' ,// 录音错误信息
    isRecognizing: false // 语音识别中状态
  },

  onLoad() {
    // 初始化录音管理器和音频上下文
    const recorderManager = wx.getRecorderManager()
    const innerAudioContext = wx.createInnerAudioContext()
    
    this.setData({
      recorderManager,
      innerAudioContext
    })

    // 录音开始监听，确认录音启动
    recorderManager.onStart(() => {
      console.log('AAC录音已成功启动');
      this.setData({ recordingError: '' });
    });

    // 录音错误监听
    recorderManager.onError((err) => {
      console.error('录音错误:', err);
      const errorMsg = {
        10001: '当前设备不支持AAC录音',
        10002: '录音参数错误',
        10003: '需要录音权限，请在设置中开启'
      }[err.errCode] || `录音失败: ${err.errMsg}`;
      
      this.setData({
        recordingError: errorMsg,
        isRecording: false
      });
      this.stopRecording();
    });

    // 录音结束回调 - 核心修改：不创建语音消息，仅填充识别文字到输入框
    recorderManager.onStop((res) => {
      const { tempFilePath, duration } = res;
      this.setData({
        recordedFilePath: tempFilePath,
        recordedDuration: Math.ceil(duration / 1000)
      });
      
      // 移除自动创建语音消息的逻辑
      // this.createVoiceMessage(tempFilePath, Math.ceil(duration / 1000));
      
      // 上传语音并获取识别文字（填充到输入框）
      this.uploadVoiceToBackend(tempFilePath);
    });

    // 音频播放控制完善
    innerAudioContext.onEnded(() => {
      this.setData({ playingIndex: -1 });
    });
    
    innerAudioContext.onError((err) => {
      console.error('播放错误:', err);
      this.setData({ playingIndex: -1 });
      wx.showToast({ title: '播放失败', icon: 'none' });
    });
  },

  // 输入框内容变化时触发
  onInputChange(e) {
    this.setData({
      inputValue: e.detail.value
    });
  },

  // 开始录音 - AAC格式配置
  startRecording() {
    if (!this.data.isRecording) return;

    const options = {
      duration: 60000, // 最长1分钟
      sampleRate: 16000, // 匹配后端/百度识别常用采样率
      numberOfChannels: 1, // 单声道（减少文件体积）
      encodeBitRate: 64000, // AAC推荐比特率
      format: 'aac', // AAC格式
      frameSize: 50
    };

    this.data.recorderManager.start(options);
    console.log('AAC录音开始，参数:', options);
    
    // 开始计时和动画
    this.startRecordingTimer();
    this.startVoiceAnimation();
  },

  // 显示录音模态框（长按触发）
  showRecordingModal() {
    this.setData({
      isRecording: true,
      recordingSeconds: 0,
      recordingTime: "00:00",
      recordingError: ''
    });
    
    // 延迟一点开始，确保长按动作确认
    setTimeout(() => {
      this.startRecording();
    }, 300);
  },

  // 停止录音
  stopRecording() {
    if (!this.data.isRecording) return;

    // 停止录音
    this.data.recorderManager.stop();
    
    // 清除计时器和动画
    if (this.data.recordingTimer) {
      clearInterval(this.data.recordingTimer);
    }
    if (this.data.animationTimer) {
      clearInterval(this.data.animationTimer);
    }

    // 重置状态
    this.setData({
      isRecording: false,
      animationState: 0
    });
  },

  // 取消录音
  cancelRecording() {
    this.stopRecording();
    console.log("录音已取消");
    // 清除临时文件路径和输入框（若有未确认的识别文字）
    this.setData({
      recordedFilePath: '',
      recordedDuration: 0,
      inputValue: ''
    });
  },

  // 开始录音计时器
  startRecordingTimer() {
    // 清除可能存在的旧计时器
    if (this.data.recordingTimer) {
      clearInterval(this.data.recordingTimer);
    }
    
    // 重置计时
    this.setData({
      recordingSeconds: 0,
      recordingTime: "00:00"
    });
    
    // 每秒更新一次时间
    this.data.recordingTimer = setInterval(() => {
      let seconds = this.data.recordingSeconds + 1;
      let minutes = Math.floor(seconds / 60);
      let remainingSeconds = seconds % 60;
      
      // 格式化时间为 MM:SS 格式
      let timeString = `${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
      
      this.setData({
        recordingSeconds: seconds,
        recordingTime: timeString
      });
      
      // 限制最长录音时间为1分钟
      if (seconds >= 60) {
        this.stopRecording();
      }
    }, 1000);
  },

  // 开始语音动画
  startVoiceAnimation() {
    // 清除可能存在的旧动画
    if (this.data.animationTimer) {
      clearInterval(this.data.animationTimer);
    }
    
    // 每300ms更新一次动画状态
    this.data.animationTimer = setInterval(() => {
      let state = this.data.animationState;
      this.setData({
        animationState: (state + 1) % 4 // 循环 0-3 的状态
      });
    }, 300);
  },

  // 播放语音
  playVoice(e) {
    const { index, path } = e.currentTarget.dataset;
    const { innerAudioContext, playingIndex } = this.data;

    // 停止当前播放
    if (playingIndex === index) {
      innerAudioContext.stop();
      this.setData({ playingIndex: -1 });
      return;
    }

    // 播放新语音
    innerAudioContext.src = path;
    innerAudioContext.play();
    this.setData({ playingIndex: index });
  },

  // 上传语音文件到后端（识别后填充到输入框）
  uploadVoiceToBackend(filePath) {
    this.setData({ 
      isLoading: false,    // 区分识别和思考状态
      isRecognizing: true  // 开始识别
    });
    const userInfo = wx.getStorageSync('userInfo');
  
    // 先检查文件是否存在
    wx.getFileInfo({
      filePath,
      success: () => {
        this.doUploadVoice(filePath, userInfo);
      },
      fail: (err) => {
        console.error('获取文件信息失败:', err);
        this.setData({ isRecognizing: false });
        this.showErrorReply('录音文件损坏，请重试');
      }
    });
  },

  // 实际执行上传操作
  doUploadVoice(filePath, userInfo) {
    wx.uploadFile({
      url: getApp().globalData.baseUrl + '/api/voice/recognize',
      filePath: filePath,
      name: 'file', // 与后端保持一致
      header: {
        'content-type': 'multipart/form-data'
      },
      formData: {
        'id': userInfo.data?.id || '',
        'format': 'aac' // 告知后端当前格式为AAC
      },
      timeout: 30000, // 30秒超时设置
      success: (res) => {
        this.setData({ isRecognizing: false }); // 结束识别状态
        if (res.statusCode !== 200) {
          this.showErrorReply(`服务器错误: ${res.statusCode}`);
          return;
        }

        try {
          const result = JSON.parse(res.data);
          if (result.code === 200 && result.data) {
            // 核心修改：将识别结果填充到输入框，不自动发送
            this.setData({
              inputValue: result.data, // 识别文字写入输入框
              isLoading: false
            });
            // 提示用户已识别完成
            wx.showToast({ title: '语音识别完成，可编辑后发送', icon: 'none' });
          } else {
            this.showErrorReply(result.message || '语音识别失败，请重试');
          }
        } catch (e) {
          console.error('解析响应失败:', e);
          this.showErrorReply('数据解析错误，请重试');
        }
      },
      fail: (err) => {
        this.setData({ isRecognizing: false }); // 结束识别状态
        console.error('语音上传失败:', err);
        const errorMsg = err.errMsg.includes('timeout') 
          ? '上传超时，请检查网络' 
          : '语音上传失败，请重试';
        this.showErrorReply(errorMsg);
      },
      complete: () => {
      }
    });
  },

  // 发送消息（核心修改：同时包含文字和语音信息）
  sendMessage() {
    // 获取输入框内容（可能是手动输入或语音识别结果）
    const inputValue = this.data.inputValue?.trim();
    if (!inputValue) {
      wx.showToast({ title: '请输入或识别语音内容', icon: 'none' });
      return;
    }

    // 创建消息（同时包含文字和语音信息）
    const newMessage = {
      isUser: true,
      type: 'text', // 主要类型为文字
      content: inputValue,
      // 附加语音信息（如果有）
      voice: this.data.recordedFilePath ? {
        path: this.data.recordedFilePath,
        duration: this.data.recordedDuration
      } : null,
      timestamp: new Date().getTime()
    };

    // 更新消息列表并滚动到底部
    this.setData({
      messages: [...this.data.messages, newMessage],
      inputValue: '', // 清空输入框
      recordedFilePath: '', // 清空录音文件路径
      recordedDuration: 0,  // 清空录音时长
      scrollTop: 99999,
      hasStartedConversation: true
    });

    // 发送消息到后端获取教练回复（仅传文字）
    this.sendTextToCoach(inputValue);
  },

  // 将文字发送给教练接口（仅传文字内容）
  sendTextToCoach(text) {
    this.setData({ 
      isLoading: true,      // 显示思考状态
      isRecognizing: false  // 确保识别状态关闭
    });
    this.setData({ isLoading: true });
    const preferences = wx.getStorageSync('preferences');
    const target = wx.getStorageSync('target');
    const duration = wx.getStorageSync('duration');
    const userInfo = wx.getStorageSync('userInfo');

    wx.request({
      url: getApp().globalData.baseUrl + '/api/plan/Prompt2Plan',
      method: 'POST',
      data: {
        id: userInfo.data?.id,
        prompt: text, // 仅传递文字内容
        preferences: preferences,
        target: target,
        duration: duration,
      },
      timeout: 15000,
      success: (res) => {
        console.log('教练回复数据:', res.data);
        
        if (res.statusCode !== 200) {
          this.showErrorReply(`服务器错误: ${res.statusCode}`);
          return;
        }

        const coachReply = res.data.data?.info;
        if (coachReply) {
          this.setData({
            messages: [...this.data.messages, {
              isUser: false,
              type: 'text',
              content: coachReply,
              timestamp: new Date().getTime()
            }],
            showResetBtn: true,
            scrollTop: 99999
          });
        } else {
          this.showErrorReply(res.data.message || '未获取到教练回复');
        }
      },
      fail: (err) => {
        console.error('接口请求失败', err);
        this.showErrorReply(err.errMsg.includes('timeout') ? '请求超时，请稍后再试' : '发送失败，请重试');
      },
      complete: () => {
        this.setData({ isLoading: false });
      }
    });
  },

  // 显示错误回复
  showErrorReply(message = '抱歉，暂时无法获取回复，请稍后再试') {
    this.setData({
      messages: [...this.data.messages, {
        isUser: false,
        type: 'text',
        content: message,
        timestamp: Date.now()
      }],
      scrollTop: 999999
    });
  },

  // 重新定制
  resetCustomization() {
    this.setData({
      inputValue: '',
      showResetBtn: false,
      scrollTop: 99999,
      messages: []
    });
  },

  // 页面卸载时清理资源
  onUnload() {
    // 清理计时器
    if (this.data.recordingTimer) clearInterval(this.data.recordingTimer);
    if (this.data.animationTimer) clearInterval(this.data.animationTimer);
    
    // 停止音频播放和录音
    if (this.data.innerAudioContext) {
      this.data.innerAudioContext.stop();
      this.data.innerAudioContext.destroy();
    }
    if (this.data.recorderManager) {
      this.data.recorderManager.stop();
    }
  }
})